home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 4 / Info_Mac IV CD-ROM (Pacific HiTech Inc.)(August 1994).iso / Development / General / PTR-TCL v2.1 / 4) header symbols / Munge.c < prev    next >
Text File  |  1994-02-09  |  8KB  |  379 lines
  1. /*
  2.  * munge.c
  3.  */
  4.  
  5. #include <string.h>
  6. #include <TextUtils.h>
  7.  
  8. #define isalfa(x) ((((x)>='A')&&((x)<='Z'))||(((x)>='a')&&((x)<='z'))||((x)=='_')||(((x)>='0')&&((x)<='9')))
  9.  
  10. extern void Idle ( void ) ;
  11. extern short vRefNum ;
  12. void MungeFolder ( long parID ) ;
  13. extern void Message ( unsigned char * ) ;
  14. extern Boolean DoLine ( unsigned char * line ) ;
  15.  
  16.  
  17. unsigned char global_token [ 100 ] ;
  18.  
  19. CInfoPBRec rec ;
  20. short err ;
  21. Str63 name ;
  22. Str255 str ;
  23. short lineNo ;
  24.  
  25.  
  26. static void
  27. CopyP ( unsigned char * from , unsigned char * to ) {
  28.     BlockMove ( from , to , 1 + * from ) ;
  29. }
  30.  
  31.  
  32. static void
  33. ConcP ( unsigned char * to , unsigned char * tail ) {
  34.  
  35. short len = * tail ;
  36.     if ( len + * to > 255 ) {
  37.         len = 255 - * to ;
  38.     }
  39.     BlockMove ( tail + 1 , to + * to + 1 , len ) ;
  40.     * to += len ;
  41. }
  42.  
  43.  
  44. static void
  45. ErrMsg ( unsigned char * why , unsigned char * file , short code ) {
  46.  
  47. Str15 nn ;
  48. long tick ;
  49. static long lastBeep = 0 ;
  50.  
  51.     NumToString ( code , nn ) ;
  52.     CopyP ( "\p ERROR " , str ) ;
  53.     ConcP ( str , why ) ;
  54.     ConcP ( str , "\p " ) ;
  55.     ConcP ( str , nn ) ;
  56.     ConcP ( str , "\p\r" ) ;
  57.     Message ( str ) ;
  58.     tick = TickCount ( ) + 30 ;
  59.     if ( lastBeep < tick - 600 ) { /* Only beep every 10 seconds if lots of errors */
  60.         SysBeep ( 20 ) ;
  61.         lastBeep = tick ;
  62.     }
  63.     do {
  64.         Idle ( ) ;
  65.     } while ( TickCount ( ) < tick ) ;
  66. }
  67.  
  68.  
  69. static long
  70. GetLine ( Handle text , long pos , unsigned char * into ) {
  71.  
  72. long end = GetHandleSize ( text ) ;
  73.  
  74.     lineNo ++ ;
  75.     * into = 0 ;
  76.     while ( pos < end ) {
  77.         if ( * into == 255 ) {
  78.             ErrMsg ( "\pLong Line!" , "\pLine" , lineNo ) ;
  79.             return pos ;
  80.         }
  81.         ( * into ) ++ ;
  82.         into [ * into ] = ( * text ) [ pos ] ;
  83.         pos ++ ;
  84.         if ( into [ * into ] == '\r' ) {
  85.             return pos ;
  86.         }
  87.     }
  88.     return pos ;
  89. }
  90.  
  91.  
  92. static long
  93. PutLine ( Handle text , long pos , long len , unsigned char * str ) {
  94.     ConcP ( str , "\p// " ) ; /* Comment out old line */
  95.     Munger ( text , pos , NULL , 0L , str + 1 , * str ) ;
  96.     return pos + len + * str ;
  97. }
  98.  
  99. static long
  100. token ( Handle text , long pos , long end , char * tok ) {
  101.  
  102. char ch ;
  103. Boolean f = 0 ;
  104.  
  105.     while ( pos < end ) {
  106.         ch = ( * text ) [ pos ] ;
  107.         pos ++ ;
  108.         if ( isalfa ( ch ) ) {
  109.             f = 1 ;
  110.             * ( tok ++ ) = ch ;
  111.         } else {
  112.             if ( f ) {
  113.                 * tok = 0 ;
  114.                 if ( ch == '\r' ) {
  115.                     pos -- ;
  116.                 }
  117.                 return pos ;
  118.             }
  119.             if ( ch == '\r' ) {
  120.                 * tok = ch ;
  121.                 tok [ 1 ] = 0 ;
  122.                 return pos ;
  123.             }
  124.         }
  125.     }
  126.     return pos ;
  127. }
  128.  
  129.  
  130. /* This function contains the total text of a TEXT file. */
  131. /* The contents of the handle will be re-written to disk when done if true returned. */
  132. /* Call Idle ( ) now and then for lengthy tasks */
  133. static Boolean
  134. MungeHandle ( Handle text ) {
  135.  
  136. Handle hh ;
  137.  
  138.     if ( 0 <= Munger ( text , 0 , & global_token [ 1 ] , global_token [ 0 ] , NULL , 0L ) ) {
  139.         return false ;
  140.     }
  141.     hh = NewHandle ( 0L ) ;
  142.     PtrAndHand ( "#ifndef " , hh , 8 ) ;
  143.     PtrAndHand ( & global_token [ 1 ] , hh , global_token [ 0 ] ) ;
  144.     PtrAndHand ( "\r# define " , hh , 10 ) ;
  145.     PtrAndHand ( & global_token [ 1 ] , hh , global_token [ 0 ] ) ;
  146.     PtrAndHand ( "\r\r" , hh , 2 ) ;
  147.     HandAndHand ( text , hh ) ;
  148.     PtrAndHand ( "\r#endif\r" , hh , 8 ) ;
  149.     SetHandleSize ( text , GetHandleSize ( hh ) ) ;
  150.     BlockMove ( * hh , * text , GetHandleSize ( hh ) ) ;
  151.     DisposeHandle ( hh ) ;
  152.     return true ;
  153. }
  154.  
  155. #if 0
  156. static Boolean
  157. MungeHandle ( Handle text ) {
  158.  
  159. long end = GetHandleSize ( text ) ;
  160. long pos = 0 ;
  161. int level = 0 ;
  162. char tok [ 256 ] ;
  163. Boolean aGoto = 0 ;
  164. Boolean aReturn = 0 ;
  165. Boolean aGotoOK = 0 ;
  166. Boolean aReturnOK = 0 ;
  167. Boolean aNL = 0 ;
  168. long line = 0 ;
  169. Str255 ss ;
  170. Str15 num ;
  171. Boolean aDec = 0 ;
  172.  
  173.     while ( pos < end ) {
  174.         aDec = 0 ;
  175.         pos = token ( text , pos , end , tok ) ;
  176.         if ( ! strcmp ( tok , "TRY" ) || ! strcmp ( tok , "TRY_MULTIPLE" ) ) {
  177.             level ++ ;
  178.         } else
  179.         if ( ! strcmp ( tok , "ENDTRY" ) || ! strcmp ( tok , "DONE" ) ) {
  180.             aNL = 1 ;
  181.             aDec = 1 ;
  182.         } else
  183.         if ( ! strcmp ( tok , "goto" ) ) {
  184.             aGoto = 1 ;
  185.         } else
  186.         if ( ! strcmp ( tok , "return" ) ) {
  187.             aReturn = 1 ;
  188.         } else
  189.         if ( ! strcmp ( tok , "\r" ) ) {
  190.             line ++ ;
  191.             aNL = 1 ;
  192.         } else
  193.         if ( ! strcmp ( tok , "GOTO_OK" ) ) {
  194.             aGotoOK = 1 ;
  195.         } else
  196.         if ( ! strcmp ( tok , "RETURN_OK" ) ) {
  197.             aReturnOK = 1 ;
  198.         }
  199.         if ( aGotoOK ) {
  200.             aGoto = 0 ;
  201.         }
  202.         if ( aReturnOK ) {
  203.             aReturn = 0 ;
  204.         }
  205.         if ( aNL ) {
  206.             if ( level ) {
  207.                 if ( aReturn ) {
  208.                     CopyP ( "\p RETURN error line " , ss ) ;
  209.                     NumToString ( line , num ) ;
  210.                     ConcP ( ss , num ) ;
  211.                     Message ( ss );
  212.                 }
  213.                 if ( aGoto ) {
  214.                     CopyP ( "\p GOTO error line " , ss ) ;
  215.                     NumToString ( line , num ) ;
  216.                     ConcP ( ss , num ) ;
  217.                     Message ( ss );
  218.                 }
  219.             }
  220.             if ( aDec ) {
  221.                 level -- ;
  222.             }
  223.             if ( level < 0 ) {
  224.                 CopyP ( "\p level error line " , ss ) ;
  225.                 NumToString ( line , num ) ;
  226.                 ConcP ( ss , num ) ;
  227.                 Message ( ss );
  228.             }
  229.             aNL = 0 ;
  230.             aGoto = 0 ;
  231.             aReturn = 0 ;
  232.             aGotoOK = 0 ;
  233.             aReturnOK = 0 ;
  234.             if ( ! ( line % 10 ) ) {
  235.                 Idle ( ) ;
  236.             }
  237.         }
  238.     }
  239.  
  240.     if ( level ) {
  241.         Message ( "\p END level error" ) ;
  242.     }
  243.     return false ;
  244. }
  245. #endif
  246.  
  247.  
  248. static void
  249. MungeFile ( short vRef , long parID , unsigned char * fn ) {
  250.  
  251. Handle text ;
  252. short ref = 0 ;
  253. long size ;
  254. Boolean doWrite ;
  255. int pos = 0 ;
  256. unsigned char * pp ;
  257. int cnt ;
  258.  
  259.     Message ( fn ) ;
  260.     if ( fn [ * fn ] != 'h' ) {
  261.         return ;
  262.     }
  263.     global_token [ ++ pos ] = '_' ;
  264.     global_token [ ++ pos ] = '_' ;
  265.     pp = fn + 1 ;
  266.     cnt = * fn ;
  267.     while ( cnt > 0 ) {
  268.         cnt -- ;
  269.         if ( ( * pp >= 'a' && * pp <= 'z' ) || ( *pp >= 'A' && *pp <= 'Z' ) ) {
  270.             global_token [ ++ pos ] = * ( pp ++ ) ;
  271.         } else {
  272.             if ( * pp != '.' ) {
  273.                 global_token [ ++ pos ] = '_' ;
  274.                 pp ++ ;
  275.             } else {
  276.                 break ; // Don't want .h
  277.             }
  278.         }
  279.     }
  280.     global_token [ ++ pos ] = '_' ;
  281.     global_token [ ++ pos ] = '_' ;
  282.     global_token [ 0 ] = pos ;
  283.     UpperText ( ( Ptr ) & global_token [ 1 ] , global_token [ 0 ] ) ;
  284.  
  285.     err = HOpenDF ( vRef , parID , fn , fsRdWrPerm , & ref ) ;
  286.     if ( err ) {
  287.         ErrMsg ( "\pOpening" , fn , err ) ;
  288.         return ;
  289.     }
  290.     err = GetEOF ( ref , & size ) ;
  291.     if ( ! err ) {
  292.         err = SetFPos ( ref , fsFromStart , 0L ) ;
  293.     }
  294.     if ( err ) {
  295.         ErrMsg ( "\pStarting" , fn , err ) ;
  296.         FSClose ( ref ) ;
  297.         return ;
  298.     }
  299.     text = NewHandle ( size ) ;
  300.     if ( ! text ) {
  301.         ErrMsg ( "\pAllocating" , fn , MemError ( ) ) ;
  302.         FSClose ( ref ) ;
  303.         return ;
  304.     }
  305.     HLock ( text ) ;
  306.     err = FSRead ( ref , & size , * text ) ;
  307.     if ( err ) {
  308.         ErrMsg ( "\pReading" , fn , err ) ;
  309.         FSClose ( ref ) ;
  310.         DisposeHandle ( text ) ;
  311.     }
  312.     HUnlock ( text ) ;
  313.     doWrite = MungeHandle ( text ) ;
  314.     if ( doWrite ) {
  315.         size = GetHandleSize ( text ) ;
  316.         err = SetEOF ( ref , size ) ;
  317.         if ( ! err ) {
  318.             err = SetFPos ( ref , fsFromStart , 0L ) ;
  319.         }
  320.         if ( err ) {
  321.             ErrMsg ( "\pFinishing" , fn , err ) ;
  322.             FSClose ( ref ) ;
  323.             DisposeHandle ( text ) ;
  324.             return ;
  325.         }
  326.         HLock ( text ) ;
  327.         err = FSWrite ( ref , & size , * text ) ;
  328.         if ( err ) {
  329.             ErrMsg ( "\pWriting" , fn , err ) ;
  330.             FSClose ( ref ) ;
  331.             DisposeHandle ( text ) ;
  332.             return ;
  333.         }
  334.     }
  335.     err = FSClose ( ref ) ;
  336.     if ( doWrite && ! err ) {
  337.         err = FlushVol ( NULL , vRef ) ;
  338.     }
  339.     DisposeHandle ( text ) ;
  340.     if ( err ) {
  341.         ErrMsg ( "\pClosing" , fn , err ) ;
  342.     }
  343.     Message ( "\p DONE\r" ) ;
  344. }
  345.  
  346.  
  347. void
  348. MungeFolder ( long parID ) {
  349.  
  350. short ix ;
  351.  
  352.     for ( ix = 1 ; ix > 0 ; ix ++ ) {
  353.         rec . hFileInfo . ioCompletion = 0L ;
  354.         rec . hFileInfo . ioFVersNum = 0 ;
  355.         rec . hFileInfo . ioNamePtr = name ;
  356.         rec . hFileInfo . ioVRefNum = vRefNum ;
  357.         rec . hFileInfo . ioDirID = parID ;
  358.         rec . hFileInfo . ioFDirIndex = ix ;
  359.         err = PBGetCatInfoAsync ( & rec ) ;
  360.         do {
  361.             Idle ( ) ;
  362.         } while ( rec . hFileInfo . ioResult == 1 ) ;
  363.         err = rec . hFileInfo . ioResult ;
  364.         if ( err ) {
  365.             break ;
  366.         }
  367.         if ( rec . hFileInfo . ioFlAttrib & 0x10 ) { /* Folder */
  368.             CopyP ( "\p\r•Entering Folder " , str ) ;
  369.             ConcP ( str , name ) ;
  370.             ConcP ( str , "\p\r" ) ;
  371.             Message ( str ) ;
  372.             MungeFolder ( rec . hFileInfo . ioDirID ) ;
  373.             Message ( "\p---- Leaving folder ----\r\r" ) ;
  374.         } else if ( rec . hFileInfo . ioFlFndrInfo . fdType == 'TEXT' ) {
  375.             MungeFile ( vRefNum , parID , name ) ;
  376.         }
  377.     }
  378. }
  379.